﻿using System;
using System.IO;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Unicode;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using RotovapPlatform.Domain.Common;
using RotovapPlatform.Domain.Equipment.DeviceParameters;

namespace RotovapPlatform.Infrastructure.Services
{
	/// <summary>
	/// 设备参数服务实现
	/// </summary>
	public class DeviceParameterService : IDeviceParameterService
	{
		private readonly ILogger<DeviceParameterService> _logger;
		private readonly string _configFilePath;
		private readonly string _defaultConfigFilePath;
		private DeviceParametersEntity _cachedParameters;
		private readonly JsonSerializerOptions _jsonOptions;

		// 添加参数更新事件
		public event EventHandler<EventArgs> ParametersUpdated;

		/// <summary>
		/// 构造函数
		/// </summary>
		/// <param name="logger">日志记录器</param>
		/// <param name="configFilePath">配置文件路径</param>
		/// <param name="defaultConfigFilePath">默认配置文件路径</param>
		public DeviceParameterService(
			ILogger<DeviceParameterService> logger,
			string configFilePath = "Config/deviceParameters.json",
			string defaultConfigFilePath = "Config/defaultDeviceParameters.json")
		{
			_logger = logger;
			_configFilePath = configFilePath;
			_defaultConfigFilePath = defaultConfigFilePath;

			// 确保配置目录存在
			var configDir = Path.GetDirectoryName(_configFilePath);
			if (!string.IsNullOrEmpty(configDir) && !Directory.Exists(configDir))
			{
				Directory.CreateDirectory(configDir);
			}

			// 配置JSON序列化选项
			_jsonOptions = new JsonSerializerOptions
			{
				WriteIndented = true,
				Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
				PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
				AllowTrailingCommas = true,
				ReadCommentHandling = JsonCommentHandling.Skip,
				PropertyNameCaseInsensitive = true // 添加大小写不敏感选项，提高兼容性
			};

			_logger.LogInformation($"设备参数服务初始化完成，配置文件路径: {_configFilePath}，默认配置文件路径: {_defaultConfigFilePath}");
		}

		/// <summary>
		/// 获取当前设备参数
		/// </summary>
		/// <returns>设备参数</returns>
		public async Task<DeviceParametersEntity> GetParametersAsync()
		{
			Console.WriteLine("DeviceParameterService.GetParametersAsync 方法被调用");

			// 如果已缓存，直接返回
			if (_cachedParameters != null)
			{
				Console.WriteLine("返回已缓存的设备参数");
				return _cachedParameters;
			}

			try
			{
				// 检查配置文件是否存在
				Console.WriteLine($"检查配置文件是否存在: {_configFilePath}");
				if (File.Exists(_configFilePath))
				{
					Console.WriteLine($"配置文件存在，开始读取");
					// 读取配置文件
					var json = await File.ReadAllTextAsync(_configFilePath);
					Console.WriteLine($"配置文件读取完成，长度: {json.Length}");

					try
					{
						Console.WriteLine("开始反序列化配置文件");
						_cachedParameters = JsonSerializer.Deserialize<DeviceParametersEntity>(json, _jsonOptions);
						Console.WriteLine($"配置文件反序列化成功，Motors数量: {_cachedParameters?.Motors?.Count ?? 0}");
						_logger.LogInformation($"从文件 {_configFilePath} 加载设备参数成功");
					}
					catch (JsonException jsonEx)
					{
						Console.WriteLine($"解析配置文件失败: {jsonEx.Message}");
						_logger.LogError(jsonEx, $"解析配置文件失败，尝试使用默认配置: {jsonEx.Message}");
						// 如果解析失败，使用默认配置
						Console.WriteLine("尝试创建默认参数");
						_cachedParameters = await CreateDefaultParametersAsync();
					}
				}
				else
				{
					// 如果配置文件不存在，创建默认配置
					Console.WriteLine("配置文件不存在，创建默认配置");
					_cachedParameters = await CreateDefaultParametersAsync();
					await SaveParametersAsync(_cachedParameters);
					Console.WriteLine($"默认设备参数已保存到 {_configFilePath}");
					_logger.LogInformation($"创建默认设备参数并保存到 {_configFilePath}");
				}

				// 确保不返回null
				if (_cachedParameters == null)
				{
					Console.WriteLine("创建了默认的空设备参数对象");
					_cachedParameters = new DeviceParametersEntity();
					_logger.LogWarning("创建了默认的空设备参数对象");
				}

				// 确保集合不为null
				if (_cachedParameters.Motors == null)
				{
					Console.WriteLine("设备参数中Motors集合为null，初始化为空列表");
					_cachedParameters.Motors = new List<Motor>();
				}

				if (_cachedParameters.Pumps == null)
				{
					Console.WriteLine("设备参数中Pumps集合为null，初始化为空列表");
					_cachedParameters.Pumps = new List<Pump>();
				}

				if (_cachedParameters.Sensors == null)
				{
					Console.WriteLine("设备参数中Sensors集合为null，初始化为空列表");
					_cachedParameters.Sensors = new List<Sensor>();
				}

				if (_cachedParameters.ProcessParameters == null)
				{
					Console.WriteLine("设备参数中ProcessParameters字典为null，初始化为空字典");
					_cachedParameters.ProcessParameters = new Dictionary<string, ProcessParameter>();
				}

				Console.WriteLine($"DeviceParameterService.GetParametersAsync 返回设备参数，Motors数量: {_cachedParameters?.Motors?.Count ?? 0}");
				return _cachedParameters;
			}
			catch (Exception ex)
			{
				Console.WriteLine($"加载设备参数失败: {ex.Message}");
				Console.WriteLine($"异常堆栈: {ex.StackTrace}");
				_logger.LogError(ex, $"加载设备参数失败: {ex.Message}");
				// 出错时返回空对象，避免空引用异常
				return new DeviceParametersEntity();
			}
		}

		/// <summary>
		/// 保存设备参数
		/// </summary>
		/// <param name="parameters">设备参数实体</param>
		/// <returns>操作结果</returns>
		public async Task<OperationResult> SaveParametersAsync(DeviceParametersEntity parameters)
		{
			try
			{
				Console.WriteLine("DeviceParameterService.SaveParametersAsync 方法被调用");
				if (parameters == null)
				{
					_logger.LogError("保存设备参数失败: 参数为空");
					return OperationResult.Fail("保存设备参数失败: 参数为空");
				}

				// 创建配置文件目录（如果不存在）
				var directory = Path.GetDirectoryName(_configFilePath);
				if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
				{
					Directory.CreateDirectory(directory);
				}

				// 序列化为JSON
				string json = JsonSerializer.Serialize(parameters, new JsonSerializerOptions
				{
					WriteIndented = true,
					PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
					Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
				});

				// 写入文件
				await File.WriteAllTextAsync(_configFilePath, json);

				// 更新缓存
				_cachedParameters = parameters;

				// 触发参数更新事件
				OnParametersUpdated();

				_logger.LogInformation("设备参数已成功保存到 {FilePath}", _configFilePath);
				return OperationResult.Ok("设备参数保存成功");
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, "保存设备参数失败");
				return OperationResult.Fail($"保存设备参数失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 重置为默认参数
		/// </summary>
		/// <returns>操作结果</returns>
		public async Task<OperationResult> ResetToDefaultAsync()
		{
			try
			{
				// 创建默认参数
				var defaultParameters = await CreateDefaultParametersAsync();

				// 保存默认参数
				var result = await SaveParametersAsync(defaultParameters);

				_logger.LogInformation("重置为默认参数成功");
				return result;
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"重置为默认参数失败: {ex.Message}");
				return OperationResult.Fail($"重置为默认参数失败: {ex.Message}");
			}
		}

		/// <summary>
		/// 导出参数到文件
		/// </summary>
		/// <param name="filePath">文件路径</param>
		/// <returns>是否成功</returns>
		public async Task<bool> ExportParametersAsync(string filePath)
		{
			try
			{
				// 获取当前参数
				var parameters = await GetParametersAsync();

				// 序列化为JSON
				var json = JsonSerializer.Serialize(parameters, _jsonOptions);

				// 写入文件
				await File.WriteAllTextAsync(filePath, json);

				_logger.LogInformation($"导出设备参数到 {filePath} 成功");
				return true;
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"导出设备参数失败: {ex.Message}");
				return false;
			}
		}

		/// <summary>
		/// 从文件导入参数
		/// </summary>
		/// <param name="filePath">文件路径</param>
		/// <returns>是否成功</returns>
		public async Task<bool> ImportParametersAsync(string filePath)
		{
			try
			{
				// 检查文件是否存在
				if (!File.Exists(filePath))
				{
					_logger.LogError($"导入设备参数失败: 文件 {filePath} 不存在");
					return false;
				}

				// 读取文件
				var json = await File.ReadAllTextAsync(filePath);

				// 反序列化
				var parameters = JsonSerializer.Deserialize<DeviceParametersEntity>(json, _jsonOptions);

				// 保存参数
				var result = await SaveParametersAsync(parameters);

				if (result.Success)
				{
					_logger.LogInformation($"从文件 {filePath} 导入设备参数成功");
				}

				return result.Success;
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, $"导入设备参数失败: {ex.Message}");
				return false;
			}
		}

		/// <summary>
		/// 获取电机参数
		/// </summary>
		/// <param name="motorId">电机ID</param>
		/// <returns>电机参数</returns>
		public async Task<Motor> GetMotorAsync(string motorId)
		{
			var parameters = await GetParametersAsync();

			foreach (var motor in parameters.Motors)
			{
				if (motor.Id == motorId)
				{
					return motor;
				}
			}

			_logger.LogWarning($"未找到电机 {motorId} 的参数");
			return null;
		}

		/// <summary>
		/// 获取泵参数
		/// </summary>
		/// <param name="pumpId">泵ID</param>
		/// <returns>泵参数</returns>
		public async Task<Pump> GetPumpAsync(string pumpId)
		{
			var parameters = await GetParametersAsync();

			// 检查Pumps集合是否为null
			if (parameters.Pumps == null)
			{
				_logger.LogWarning($"获取泵 {pumpId} 参数失败：Pumps集合为null");
				return null;
			}

			foreach (var pump in parameters.Pumps)
			{
				if (pump.Id == pumpId)
				{
					return pump;
				}
			}

			// 如果在泵集合中找不到，尝试在电机集合中查找（因为您已经将泵改为电机）
			if (parameters.Motors != null)
			{
				foreach (var motor in parameters.Motors)
				{
					if (motor.Id == pumpId)
					{
						// 创建一个转换后的泵对象
						var pump = new Pump
						{
							Id = motor.Id,
							Name = motor.Name,
							AxisId = motor.AxisId,
							Parameters = new PumpParameters
							{
								MaxSpeed = motor.Parameters?.MaxSpeed ?? 100.0,
								MaxAcceleration = motor.Parameters?.MaxAcceleration ?? 50.0,
								MaxDeceleration = motor.Parameters?.MaxDeceleration ?? 50.0,
								FlowRate = 10.0, // 默认值
								Unit = "ml/min" // 默认值
							}
						};

						_logger.LogInformation($"找到电机 {pumpId}，将其转换为泵对象");
						return pump;
					}
				}
			}

			_logger.LogWarning($"未找到泵 {pumpId} 的参数");
			return null;
		}

		/// <summary>
		/// 获取传感器参数
		/// </summary>
		/// <param name="sensorId">传感器ID</param>
		/// <returns>传感器参数</returns>
		public async Task<Sensor> GetSensorAsync(string sensorId)
		{
			var parameters = await GetParametersAsync();

			foreach (var sensor in parameters.Sensors)
			{
				if (sensor.Id == sensorId)
				{
					return sensor;
				}
			}

			_logger.LogWarning($"未找到传感器 {sensorId} 的参数");
			return null;
		}

		/// <summary>
		/// 获取工艺参数
		/// </summary>
		/// <param name="parameterName">参数名称</param>
		/// <returns>工艺参数</returns>
		public async Task<ProcessParameter> GetProcessParameterAsync(string parameterName)
		{
			var parameters = await GetParametersAsync();

			if (parameters.ProcessParameters.TryGetValue(parameterName, out var parameter))
			{
				return parameter;
			}

			_logger.LogWarning($"未找到工艺参数 {parameterName}");
			return null;
		}

		/// <summary>
		/// 清除缓存的参数，强制下次从文件重新加载
		/// </summary>
		/// <returns>任务</returns>
		public Task ClearCacheAsync()
		{
			_cachedParameters = null;
			_logger.LogInformation("已清除设备参数缓存");
			return Task.CompletedTask;
		}

		/// <summary>
		/// 创建默认参数
		/// </summary>
		/// <returns>默认参数</returns>
		private async Task<DeviceParametersEntity> CreateDefaultParametersAsync()
		{
			Console.WriteLine("DeviceParameterService.CreateDefaultParametersAsync 方法被调用");
			try
			{
				// 检查默认配置文件是否存在
				Console.WriteLine($"检查默认配置文件是否存在: {_defaultConfigFilePath}");
				if (File.Exists(_defaultConfigFilePath))
				{
					Console.WriteLine("默认配置文件存在，开始读取");
					// 读取默认配置文件
					var json = await File.ReadAllTextAsync(_defaultConfigFilePath);
					Console.WriteLine($"默认配置文件读取完成，长度: {json.Length}");

					try
					{
						Console.WriteLine("开始反序列化默认配置文件");
						var parameters = JsonSerializer.Deserialize<DeviceParametersEntity>(json, _jsonOptions);
						Console.WriteLine($"默认配置文件反序列化成功，Motors数量: {parameters?.Motors?.Count ?? 0}");
						_logger.LogInformation($"从默认配置文件 {_defaultConfigFilePath} 创建设备参数成功");
						return parameters;
					}
					catch (JsonException jsonEx)
					{
						Console.WriteLine($"解析默认配置文件失败: {jsonEx.Message}");
						Console.WriteLine($"异常堆栈: {jsonEx.StackTrace}");
						_logger.LogError(jsonEx, $"解析默认配置文件失败: {jsonEx.Message}");
					}
				}
				else
				{
					Console.WriteLine($"默认配置文件不存在: {_defaultConfigFilePath}");
					_logger.LogWarning($"默认配置文件 {_defaultConfigFilePath} 不存在，创建空的设备参数");
				}

				// 如果无法从默认配置文件加载，创建一个空对象
				Console.WriteLine("创建一个空的设备参数对象");
				return new DeviceParametersEntity
				{
					DeviceInfo = new DeviceInfo
					{
						Name = "旋转蒸发仪",
						Model = "RP-1000",
						SerialNumber = "DEFAULT001",
						FirmwareVersion = "1.0.0"
					},
					Motors = new List<Motor>(),
					Pumps = new List<Pump>(),
					Sensors = new List<Sensor>(),
					ProcessParameters = new Dictionary<string, ProcessParameter>()
				};
			}
			catch (Exception ex)
			{
				Console.WriteLine($"创建默认设备参数时出错: {ex.Message}");
				Console.WriteLine($"异常堆栈: {ex.StackTrace}");
				_logger.LogError(ex, $"创建默认设备参数失败: {ex.Message}");
				// 出错时返回空对象
				return new DeviceParametersEntity();
			}
		}

		/// <summary>
		/// 触发参数更新事件
		/// </summary>
		protected virtual void OnParametersUpdated()
		{
			ParametersUpdated?.Invoke(this, EventArgs.Empty);
		}
	}
}